包名 com.Meng

/*
*
*    @阿杰   Meng
*
*    有问题请联系：q2217444740
*
*	未完善，待后续更新。
*/

@外部依赖库("../../安卓基本库/依赖库/androidx/core-1.3.0.aar")
@外部依赖库("../../安卓基本库/依赖库/androidx/collection-1.1.0.jar")
@外部依赖库("../../安卓基本库/依赖库/androidx/coordinatorlayout-1.1.0.aar")
@导入Java("androidx.coordinatorlayout.widget.CoordinatorLayout")
类 协调布局 : 可调整边距布局组件
	
	@code
	public #<协调布局>(android.content.Context context) {
		  super(context);
	 }

	 @Override
	 public CoordinatorLayout onCreateView(android.content.Context context) {
		  CoordinatorLayout v = new CoordinatorLayout(context);/*{
			@Override
			public boolean onInterceptTouchEvent(MotionEvent ev){
				return super.onInterceptTouchEvent(ev);
			}
			@Override
			public boolean onTouchEvent(MotionEvent ev) {
				return super.onTouchEvent(ev);
			}
			@Override
			public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
				super.requestDisallowInterceptTouchEvent(disallowIntercept);
			}
			@Override
			public void onMeasureChild(View child, int parentWidthMeasureSpec, int widthUsed,
			int parentHeightMeasureSpec, int heightUsed) {
				super.onMeasureChild(child, parentWidthMeasureSpec, widthUsed,parentHeightMeasureSpec, heightUsed);
			}
			@Override
			public void onLayoutChild(View child, int layoutDirection){
				super.onLayoutChild(child, layoutDirection);
			}
			@Override
			public void onLayout(boolean changed, int l, int t, int r, int b) {
				super.onLayout(changed, l, t, r, b);
			}
			@Override
			public void dispatchDependentViewsChanged(View view) {
				super.dispatchDependentViewsChanged(view);
			}

		};*/
		v.setFitsSystemWindows(true);
		return v;
	 }

	 @Override
	 public CoordinatorLayout getView() {
		  return (CoordinatorLayout) view;
	 }
	@end

	//======
	
	方法 启用透明状态栏()
		@code
		if (android.os.Build.VERSION.SDK_INT >= 21) {
            android.view.View decorView = #取安卓窗口().getWindow().getDecorView();
            int option = decorView.getSystemUiVisibility() | android.view.View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                    | android.view.View.SYSTEM_UI_FLAG_LAYOUT_STABLE;
            decorView.setSystemUiVisibility(option);
            #取安卓窗口().getWindow().setStatusBarColor(android.graphics.Color.TRANSPARENT);
        }
		@end
	结束 方法
	
	方法 状态栏背景图片(图片路径 : 文本)
		@code 
		if (#图片路径.startsWith("/")) {
			getView().setStatusBarBackground(new android.graphics.drawable.BitmapDrawable(android.graphics.BitmapFactory.decodeFile(#图片路径)));
		} else {
			try {  
				java.io.InputStream is = context.getAssets().open(#图片路径); 
				android.graphics.drawable.Drawable drawable = android.graphics.drawable.Drawable.createFromStream(is, #图片路径);
				getView().setStatusBarBackground(drawable);
				is.close();  
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		@end
	结束 方法

	/*方法 取状态栏背景图片() : 可绘制对象
		code return getView().getStatusBarBackground();
	结束 方法*/
	
	方法 显示到状态栏(是否 : 逻辑型 = 真)
		code getView().setFitsSystemWindows(#是否);
	结束 方法
	
	@布局属性
	方法 显示组件到状态栏(组件 : 可视化组件, 是否 : 逻辑型)
		code #组件.getView().setFitsSystemWindows(#是否);
	结束 方法

	方法 状态栏背景颜色(颜色 : 整数)
		code getView().setStatusBarBackgroundColor(#颜色);
	结束 方法

	方法 取依赖组件(组件 : 可视化组件) : 集合
		code return (java.util.ArrayList)getView().getDependencies(#组件.getView());
	结束 方法

	方法 取依赖组件2(组件 : 可视化组件) : 集合
		code return (java.util.ArrayList)getView().getDependents(#组件.getView());
	结束 方法

	方法 在可视范围内(组件 : 可视化组件, x : 整数, y : 整数) : 逻辑型
		code return getView().isPointInChildBounds(#组件.getView(), #x, #y);
	结束 方法

	方法 是否重叠(组件1 : 可视化组件, 组件2 : 可视化组件) : 逻辑型
		code return getView().doViewsOverlap(#组件1.getView(),#组件2.getView());
	结束 方法

结束 类


/*
*     未完善，等后续更新
*/
@全局类
@强制输出
@导入Java("android.view.View")
@导入Java("android.view.*")
@导入Java("androidx.core.view.WindowInsetsCompat")
@导入Java("androidx.coordinatorlayout.widget.CoordinatorLayout")
@导入Java("androidx.coordinatorlayout.widget.CoordinatorLayout.Behavior")
@后缀代码("extends CoordinatorLayout.Behavior")
类 行为监听器
	
	变量 组件 为 可视化组件 = 空
	变量 依赖组件 为 可视化组件 = 空
	变量 副属组件 为 可视化组件 = 空
	变量 滚动组件 为 可视化组件 = 空
	变量 滚动顶层组件 为 可视化组件 = 空
	
	@code
	public #<行为监听器>(#<可视化组件> a, #<可视化组件> b){
		try{
		CoordinatorLayout.LayoutParams params = (CoordinatorLayout.LayoutParams)a.getView().getLayoutParams();
		params.setBehavior(this);
		} catch(#<@异常> e) {throw new RuntimeException("\n⚠️[行为监听器] 错误：此组件并非 协调布局 的子组件");}
		#组件 = a;
		#依赖组件 = b;
	}
	@end
	
	@静态
	方法 行为监听器(组件 : 可视化组件, 依赖组件 : 可视化组件) : 行为监听器
		code return new #<行为监听器>(#组件, #依赖组件);
	结束 方法
	
	属性读 组件() 为 可视化组件
		返回 本对象.组件
	结束 属性

	属性读 依赖组件() 为 可视化组件
		返回 本对象.组件
	结束 属性

	属性写 依赖组件(组件 为 可视化组件)
		本对象.依赖组件 = 组件
	结束 属性

	属性写 标记(tag 为 对象)
		code setTag(#组件.getView(), #tag);
	结束 属性

	属性读 标记() 为 对象
		code return getTag(#组件.getView());
	结束 属性

	方法 标记(组件 为 可视化组件, tag 为 对象)
		code setTag(#组件.getView(), #tag);
	结束 方法

	方法 标记(组件 为 可视化组件) 为 对象
		code return getTag(#组件.getView());
	结束 方法

	定义事件 依赖组件判断(组件 为 可视化组件, 判断组件 为 可视化组件) 为 逻辑型

	定义事件 依赖组件变化(组件 为 可视化组件, 依赖组件 为 可视化组件) 为 逻辑型

	定义事件 依赖组件移除(组件 为 可视化组件, 依赖组件 为 可视化组件)

	定义事件 滚动判断(组件 为 可视化组件, 滚动组件 为 可视化组件, 滚动顶层组件 为 可视化组件) 为 逻辑型

	定义事件 滚动开始(组件 为 可视化组件, 滚动组件 为 可视化组件)

	定义事件 滚动中(组件 为 可视化组件, 滚动组件 为 可视化组件, 消耗距离X 为 整数, 消耗距离Y 为 整数, 未消耗距离X 为 整数, 未消耗距离Y 为 整数, 类型 为 整数)

	定义事件 滚动停止(组件 为 可视化组件, 滚动组件 为 可视化组件)

	定义事件 惯性滚动判断(组件 为 可视化组件, 滚动组件 为 可视化组件) 为 逻辑型

	定义事件 惯性滚动中(组件 为 可视化组件, 滚动组件 为 可视化组件) 为 逻辑型
	
	@code
	//==== 布局相关
	
	// 给 Behavior 设置 LayoutParams 时会调用
	// 监听器绑定
	@Override
	public void onAttachedToLayoutParams(CoordinatorLayout.LayoutParams params) {
		
	}

	// LayoutParams 移除时会调用
	// 监听器取消绑定
	@Override
	public void onDetachedFromLayoutParams() {}
	
	//  CoordinatorLayout 在测量时会回调这个方法
	@Override
	public boolean onMeasureChild(CoordinatorLayout parent, View child,
	int parentWidthMeasureSpec, int widthUsed,
	int parentHeightMeasureSpec, int heightUsed) {
		return false;
	}

	//  CoordinatorLayout 在布局时会回调这个方法
	//  onLayoutChild可以用于子View视图布局的更改，
	//  修改behavior默认设置子View的行为。需要调用parent.onLayoutChild
	/**
     * @param parent CoordinatorLayout
     * @param child   子View
     * @param layoutDirection  ViewCompat.LAYOUT_DIRECTION_LTR(水平布局从左到右)
     *                         ViewCompat.LAYOUT_DIRECTION_RTL(水平布局从右到左)
     * @return  false表示不改变，true改变View的视图
     */
	@Override
	public boolean onLayoutChild(CoordinatorLayout parent, View child, int layoutDirection) {
		return false;
	}
	
	//==== 事件处理相关方法

	// 是否拦截 CoordinatorLayout 发的点击事件
	@Override
	public boolean onInterceptTouchEvent(CoordinatorLayout parent, View child, MotionEvent ev) {
		return false;
	}

	// 接收 CoordinatorLayout 发的点击事件 
	@Override
	public boolean onTouchEvent(CoordinatorLayout parent, View child, MotionEvent ev) {
		return false;
	}
	
	
	// 设置 Behavior 所在 View 之外的 View 的蒙层颜色
	@Override
	public int getScrimColor(CoordinatorLayout parent, View child) {
		return -16777216;
	}

	// 设置蒙层的透明度
	@Override
	public float getScrimOpacity(CoordinatorLayout parent, View child) {
		return 0.0f;
	}

	// 是否对 Behavior 绑定 View 下面的 View 的进行交互，
	// 默认是是根据 getScrimOpacity 的透明度决定的
	@Override
	public boolean blocksInteractionBelow(CoordinatorLayout parent, View child) {
		return getScrimOpacity(parent, child) > 0.f;
	}
	
	
	

	// 1
	// 当前 View 是否依赖指定 View 进行变化
	/**
     * 表示是否给应用Behavior的View指定一个依赖的布局，一般当依赖的View布局发生变化时
     * 不管被被依赖View的顺序怎样，被依赖的View也会重新布局
     * @param parent CoordinatorLayout 
     * @param child 绑定behavior 的View
     * @param dependency   依赖的view
     * @return 如果child是依赖的指定的View 返回true,否则返回false
     */
	@Override
	public boolean layoutDependsOn(CoordinatorLayout parent, View child, View dependency) {
		Object r = #依赖组件判断(#组件,
		dependency.getId() == (#依赖组件 == null? - 1:#依赖组件.getView().getId())?#依赖组件:(#副属组件 = new #<可视化组件>(dependency.getContext()){
			public View onCreateView(#<安卓环境> context) {
 		       return dependency;
		    }
			public View getView() {
	 	       return dependency;
		    }
		}));
		return r != null ? (boolean)r:false;
	}
	
	// 2
	// 依赖的 View(dependency)变化时的回调
	/**
     * 当依赖的视图状态位置、大小发生变化时，就会调用这个方法
     * @param parent
     * @param child
     * @param dependency
     * @return
     */
	 
	@Override
	public boolean onDependentViewChanged(CoordinatorLayout parent, View child, View dependency) {
		Object r = #依赖组件变化(#组件, 
		dependency.getId() == (#依赖组件 == null? - 1:#依赖组件.getView().getId())?#依赖组件:(#副属组件 = new #<可视化组件>(dependency.getContext()){
			public View onCreateView(#<安卓环境> context) {
 		       return dependency;
		    }
			public View getView() {
	 	       return dependency;
		    }
		}));
		return r != null ? (boolean)r:false;
	}

	// 依赖的 View 被移除时的回调
	@Override
	public void onDependentViewRemoved(CoordinatorLayout parent, View child, View dependency) {
		#依赖组件移除(#组件, 
		dependency.getId() == (#依赖组件 == null? - 1:#依赖组件.getView().getId())?#依赖组件:(#副属组件 = new #<可视化组件>(dependency.getContext()){
			public View onCreateView(#<安卓环境> context) {
 		       return dependency;
		    }
			public View getView() {
	 	       return dependency;
		    }
		}));
	}

	// 当 CoordinatorLayout 内有 NestedScrollView 开始滑动的时候回调
	// 只有返回了true才能继续接收后续滑动事件
	// 一个滚动事件等开始会触发此回调，可以在这里返回是否需要消耗本次滚动事件
	// 其中axes表示的是本次滚动事件的方向、type表示手指触摸或者是惯性滚动。
	@Override
	public boolean onStartNestedScroll(CoordinatorLayout coordinatorLayout,
	View child, View directTargetChild, View target, int axes, int type) {
		Object r = #滚动判断(#组件, 
		target.getId() == (#依赖组件 == null? - 1:#依赖组件.getView().getId())?#依赖组件:(#滚动组件 = new #<可视化组件>(target.getContext()){
			public View onCreateView(#<安卓环境> context) {
 		       return target;
		    }
			public View getView() {
	 	       return target;
		    }
		}), #滚动顶层组件 = new #<可视化组件>(directTargetChild.getContext()){
			public View onCreateView(#<安卓环境> context) {
 		       return directTargetChild;
		    }
			public View getView() {
	 	       return directTargetChild;
		    }
		});
		return r != null ? (boolean)r:false;
	}

	// 当上面的 onStartNestedScroll 返回 true,会回到该方法
	// onStartNestedScroll返回true后，该函数被调用，表示可以嵌套滑动
	// 如果 onStartNestedScroll 返回了true，则在滚动中会回调此方法，可以在这里做view做位置等等变化
	// 其中axes表示的是本次滚动事件的方向、type表示手指触摸或者是惯性滚动。
	// 判断滚动是否是竖直方向 boolean result = (axes & ViewCompat.SCROLL_AXIS_VERTICAL) != 0;
	@Override
	public void onNestedScrollAccepted(CoordinatorLayout coordinatorLayout,
	View child, View directTargetChild, View target, int axes, int type) {
		//code
	}
	
	// 在 onNestedScroll 之前回调该方法
	// 滑动前
	// 滑动事件已经产生，且在消耗滑动事件之前进行回调
	@Override
	public void onNestedPreScroll(CoordinatorLayout coordinatorLayout,
	View child, View target, int dx, int dy, int[] consumed, int type) {
		#滚动开始(#组件, 
		target.getId() == (#依赖组件 == null? - 1:#依赖组件.getView().getId())?#依赖组件:(#滚动组件 = new #<可视化组件>(target.getContext()){
			public View onCreateView(#<安卓环境> context) {
 		       return target;
		    }
			public View getView() {
	 	       return target;
		    }
		}));
	}

	// 当 CoordinatorLayout 内有 NestedScrollView 滑动过程中的回调
	// 滑动后
	// 滑动事件已经产生，且在消耗事件之后进行回调
	@Override
	public void onNestedScroll(CoordinatorLayout coordinatorLayout, View child,
	View target, int dxConsumed, int dyConsumed,
	int dxUnconsumed, int dyUnconsumed, int type) {
		#滚动中(#组件, 
		target.getId() == (#依赖组件 == null? - 1:#依赖组件.getView().getId())?#依赖组件:(#滚动组件 = new #<可视化组件>(target.getContext()){
			public View onCreateView(#<安卓环境> context) {
 		       return target;
		    }
			public View getView() {
	 	       return target;
		    }
		}),
		dxConsumed,dyConsumed,dxUnconsumed,dyUnconsumed,type);
	}
	
	// 当 CoordinatorLayout 内有 NestedScrollView 停止滑动的时候回调
	// 滑动结束
	// 一个滚动事件等结束会触发此回调，可以在这里给child添加回弹动画。
	// type表示手指触摸或者是惯性滚动。
	@Override
	public void onStopNestedScroll(CoordinatorLayout coordinatorLayout,
	View child, View target, int type) {
		#滚动停止(#组件, 
		target.getId() == (#依赖组件 == null? - 1:#依赖组件.getView().getId())?#依赖组件:(#滚动组件 = new #<可视化组件>(target.getContext()){
			public View onCreateView(#<安卓环境> context) {
 		       return target;
		    }
			public View getView() {
	 	       return target;
		    }
		}));
	}

	// 是否滑动的惯性事件处理
	@Override
	public boolean onNestedFling(CoordinatorLayout coordinatorLayout,
	View child, View target, float velocityX, float velocityY,
	boolean consumed) {
		Object r = #惯性滚动判断(#组件, 
		target.getId() == (#依赖组件 == null? - 1:#依赖组件.getView().getId())?#依赖组件:(#滚动组件 = new #<可视化组件>(target.getContext()){
			public View onCreateView(#<安卓环境> context) {
 		       return target;
		    }
			public View getView() {
	 	       return target;
		    }
		}));
		return r != null ? (boolean)r:false;
	}

	// 滑动的惯性事件开始的回调
	@Override
	public boolean onNestedPreFling(CoordinatorLayout coordinatorLayout,
	View child, View target, float velocityX, float velocityY) {
		Object r = #惯性滚动中(#组件, 
		target.getId() == #依赖组件.getView().getId()?#依赖组件:(#滚动组件 = new #<可视化组件>(target.getContext()){
			public View onCreateView(#<安卓环境> context) {
 		       return target;
		    }
			public View getView() {
	 	       return target;
		    }
		}));
		return r != null ? (boolean)r:false;
	}
	
	/*
	// 如果给CoordinatorLayout设置了fitSystemWindow=true,可以在这里自己处理WindowInsetsCompat
	@Override
	public WindowInsetsCompat onApplyWindowInsets(CoordinatorLayout coordinatorLayout,
	View child, WindowInsetsCompat insets) {
		return insets;
	}

	// 在CoordinatorLayout的requestChildRectangleOnScreen()中被调用
	@Override
	public boolean onRequestChildRectangleOnScreen(CoordinatorLayout coordinatorLayout,
	View child, #<@矩形> rectangle, boolean immediate) {
		return false;
	}*/
	@end
结束 类